/**
 * @file protocol_validator.c
 * @brief 协议验证器实现
 * @details 本文件实现了104协议的协议验证器功能，包括APDU验证、ASDU验证、序列号
 *          验证、协议状态管理等核心功能。提供完整的协议验证流程，确保接收到的
 *          协议数据符合104协议规范，包含完整的错误处理和状态管理。支持I格式、
 *          S格式、U格式APDU的验证和各种类型ASDU的验证。
 * 
 * @author zyb
 * @date 2025-10-16
 * @version 1.0
 * 
 * @note 协议验证器维护序列号状态，确保协议数据的有序性
 * @warning 验证器需要正确管理序列号，避免序列号错误导致的通信中断
 * 
 * @see protocol_validator.h
 * @see protocol_types.h
 * @see constants.h
 * @see error_codes.h
 */

#include "../include/protocol_validator.h"
#include "../../common/types/include/protocol_types.h"
#include "../../common/types/include/constants.h"
#include "../../common/error/include/error_codes.h"
#include "../../common/utils/include/validation_utils.h"
#include "../../../../../common/utils/include/buffer_utils.h"
#include "../../protocol/apdu/include/apdu_parser.h"
#include "../../protocol/asdu/include/asdu_parser.h"
#include "../../../../../common/logs/include/logger.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

// 定义模块名称
#define LOG_MODULE_NAME "PROTOCOL_VALIDATOR"

/* ==================== 协议验证器结构体实现 ==================== */

struct protocol_validator {
    uint16_t expected_send_seq;      /* 期望的发送序列号 */
    uint16_t expected_receive_seq;  /* 期望的接收序列号 */
    uint16_t max_send_seq;          /* 最大发送序列号 */
    uint16_t max_receive_seq;       /* 最大接收序列号 */
    int initialized;                /* 初始化标志 */
};

/* ==================== 协议验证器管理函数实现 ==================== */

/**
 * @brief 创建协议验证器
 * @details 创建并初始化一个新的协议验证器实例。验证器用于维护104协议的
 *          序列号状态，确保APDU和ASDU的有序性和完整性。验证器会跟踪
 *          发送和接收序列号，检测序列号错误和重复。
 * 
 * @return 协议验证器指针，失败返回NULL
 * 
 * @note 创建的验证器需要调用destroy_protocol_validator()释放内存
 * @warning 验证器创建失败时返回NULL，调用者需要检查返回值
 * 
 * @see destroy_protocol_validator
 * @see protocol_validator_t
 */
protocol_validator_t* create_protocol_validator(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "创建协议验证器");
    
    protocol_validator_t* validator = (protocol_validator_t*)malloc(sizeof(protocol_validator_t));
    if (validator == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "内存分配失败");
        return NULL;
    }
    LOG_DEBUG(LOG_MODULE_NAME, "协议验证器内存分配成功: %p", validator);
    
    /* 初始化验证器 */
    LOG_DEBUG(LOG_MODULE_NAME, "初始化协议验证器，大小: %zu", sizeof(protocol_validator_t));
    memset(validator, 0, sizeof(protocol_validator_t));
    validator->expected_send_seq = 0;
    validator->expected_receive_seq = 0;
    validator->max_send_seq = MAX_SEND_SEQUENCE_NUMBER;
    validator->max_receive_seq = MAX_RECEIVE_SEQUENCE_NUMBER;
    validator->initialized = 1;
    
    LOG_DEBUG(LOG_MODULE_NAME, "协议验证器初始化完成: 发送序列号=%d, 接收序列号=%d, 最大发送=%d, 最大接收=%d",
              validator->expected_send_seq, validator->expected_receive_seq,
              validator->max_send_seq, validator->max_receive_seq);
    
    LOG_INFO(LOG_MODULE_NAME, "协议验证器创建成功: %p", validator);
    return validator;
}

/**
 * @brief 销毁协议验证器
 * @details 释放协议验证器占用的内存资源。函数会检查指针有效性，
 *          然后释放验证器结构体内存。调用此函数后，验证器指针
 *          将变为无效，不应再使用。
 * 
 * @param validator 协议验证器指针，可以为NULL
 * 
 * @note 此函数是create_protocol_validator()的配对函数
 * @warning 调用此函数后，验证器指针变为无效，不应再使用
 * 
 * @see create_protocol_validator
 * @see protocol_validator_t
 */
void destroy_protocol_validator(protocol_validator_t* validator) {
    LOG_DEBUG(LOG_MODULE_NAME, "销毁协议验证器: %p", validator);
    
    if (validator != NULL) {
        free(validator);
        LOG_INFO(LOG_MODULE_NAME, "协议验证器销毁成功: %p", validator);
    } else {
        LOG_DEBUG(LOG_MODULE_NAME, "验证器指针为NULL，无需销毁");
    }
}

/**
 * @brief 初始化协议验证器
 * @details 初始化协议验证器的内部状态，设置序列号初始值和最大值。
 *          验证器用于维护104协议的序列号状态，确保数据的有序性。
 *          初始化后，验证器可以开始验证APDU和ASDU的序列号。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 初始化成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 * 
 * @note 初始化后的验证器序列号从0开始
 * @warning 验证器必须在使用前进行初始化
 * 
 * @see protocol_validator_t
 * @see MAX_SEND_SEQUENCE_NUMBER
 * @see MAX_RECEIVE_SEQUENCE_NUMBER
 */
protocol_error_t init_protocol_validator(protocol_validator_t* validator) {
    LOG_DEBUG(LOG_MODULE_NAME, "初始化协议验证器: %p", validator);
    
    if (validator == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    validator->expected_send_seq = 0;
    validator->expected_receive_seq = 0;
    validator->max_send_seq = MAX_SEND_SEQUENCE_NUMBER;
    validator->max_receive_seq = MAX_RECEIVE_SEQUENCE_NUMBER;
    validator->initialized = 1;
    
    LOG_DEBUG(LOG_MODULE_NAME, "验证器初始化完成: 发送序列号=%d, 接收序列号=%d, 最大发送=%d, 最大接收=%d",
              validator->expected_send_seq, validator->expected_receive_seq,
              validator->max_send_seq, validator->max_receive_seq);
    
    LOG_INFO(LOG_MODULE_NAME, "协议验证器初始化成功: %p", validator);
    return PROTOCOL_SUCCESS;
}

/* ==================== APDU验证函数实现 ==================== */

/**
 * @brief 验证APDU消息
 * @details 验证APDU消息的完整性和序列号正确性。函数会根据APDU格式
 *          （I格式、S格式、U格式）进行相应的验证。对于I格式APDU，
 *          会验证发送和接收序列号；对于S格式APDU，会验证接收序列号。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @param apdu APDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_APDU_SEQUENCE_ERROR: 序列号错误
 *         - PROTOCOL_ERROR_APDU_FORMAT_ERROR: APDU格式错误
 * 
 * @note 验证器会根据APDU格式进行相应的序列号验证
 * @warning 序列号错误可能导致通信中断，需要重新同步
 * 
 * @see apdu_t
 * @see is_i_format_apdu
 * @see is_s_format_apdu
 * @see is_u_format_apdu
 */
protocol_error_t validate_apdu_message(protocol_validator_t* validator, const apdu_t* apdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证APDU消息: 验证器=%p, APDU=%p", validator, apdu);
    
    if (validator == NULL || apdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器或APDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    if (!validator->initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器未初始化");
        return PROTOCOL_ERROR_SYSTEM_NOT_READY;
    }
    
    /* 验证APDU基本格式 */
    protocol_error_t format_result = validate_apdu_format(apdu);
    if (format_result != PROTOCOL_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "APDU格式验证失败: %d", format_result);
        return format_result;
    }
    
    /* 根据APDU格式进行特定验证 */
    if (is_i_format_apdu(apdu)) {
        LOG_DEBUG(LOG_MODULE_NAME, "验证I格式APDU");
        return validate_i_format_apdu(validator, apdu);
    } else if (is_s_format_apdu(apdu)) {
        LOG_DEBUG(LOG_MODULE_NAME, "验证S格式APDU");
        return validate_s_format_apdu(validator, apdu);
    } else if (is_u_format_apdu(apdu)) {
        LOG_DEBUG(LOG_MODULE_NAME, "验证U格式APDU");
        return validate_u_format_apdu(validator, apdu);
    }
    
    LOG_ERROR(LOG_MODULE_NAME, "未知的APDU格式");
    return PROTOCOL_ERROR_APDU_FORMAT_ERROR;
}

protocol_error_t validate_i_format_apdu(protocol_validator_t* validator, const apdu_t* apdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证I格式APDU: 验证器=%p, APDU=%p", validator, apdu);
    
    if (validator == NULL || apdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器或APDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 提取序列号 */
    uint16_t send_seq = ((uint16_t)apdu->control_field.control1 >> 1) | 
                        ((uint16_t)apdu->control_field.control2 << 7);
    
    uint16_t receive_seq = ((uint16_t)apdu->control_field.control3 >> 1) | 
                           ((uint16_t)apdu->control_field.control4 << 7);
    
    LOG_DEBUG(LOG_MODULE_NAME, "I格式APDU序列号: 发送=%d, 接收=%d, 期望发送=%d, 期望接收=%d",
              send_seq, receive_seq, validator->expected_send_seq, validator->expected_receive_seq);
    
    /* 验证发送序列号 */
    if (send_seq != validator->expected_send_seq) {
        LOG_ERROR(LOG_MODULE_NAME, "发送序列号错误: 期望=%d, 实际=%d", validator->expected_send_seq, send_seq);
        return PROTOCOL_ERROR_APDU_SEQUENCE_ERROR;
    }
    
    /* 验证接收序列号 */
    if (receive_seq != validator->expected_receive_seq) {
        LOG_ERROR(LOG_MODULE_NAME, "接收序列号错误: 期望=%d, 实际=%d", validator->expected_receive_seq, receive_seq);
        return PROTOCOL_ERROR_APDU_SEQUENCE_ERROR;
    }
    
    /* 验证序列号范围 */
    if (send_seq > validator->max_send_seq || receive_seq > validator->max_receive_seq) {
        LOG_ERROR(LOG_MODULE_NAME, "序列号超出范围: 发送=%d(最大=%d), 接收=%d(最大=%d)",
                  send_seq, validator->max_send_seq, receive_seq, validator->max_receive_seq);
        return PROTOCOL_ERROR_APDU_SEQUENCE_ERROR;
    }
    
    /* 更新期望序列号 */
    validator->expected_send_seq = (validator->expected_send_seq + 1) % SEQUENCE_NUMBER_MODULO;
    validator->expected_receive_seq = (validator->expected_receive_seq + 1) % SEQUENCE_NUMBER_MODULO;
    
    LOG_DEBUG(LOG_MODULE_NAME, "序列号更新: 期望发送=%d, 期望接收=%d",
              validator->expected_send_seq, validator->expected_receive_seq);
    
    /* 验证ASDU */
    if (apdu->length > APDU_MIN_LENGTH) {
        LOG_DEBUG(LOG_MODULE_NAME, "验证I格式APDU中的ASDU");
        asdu_t asdu;
        protocol_error_t result = extract_asdu_from_apdu(apdu, &asdu);
        if (result != PROTOCOL_SUCCESS) {
            LOG_ERROR(LOG_MODULE_NAME, "提取ASDU失败: %d", result);
            return result;
        }
        
        result = validate_asdu_message(validator, &asdu);
        free_asdu(&asdu);
        
        if (result != PROTOCOL_SUCCESS) {
            LOG_ERROR(LOG_MODULE_NAME, "ASDU验证失败: %d", result);
            return result;
        }
    }
    
    LOG_INFO(LOG_MODULE_NAME, "I格式APDU验证成功");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证S格式APDU
 * @details 验证S格式APDU的序列号正确性。S格式APDU用于确认接收到的I格式APDU，
 *          只包含接收序列号。函数会提取接收序列号，验证其是否与期望值匹配，
 *          然后更新验证器的状态。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @param apdu S格式APDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_APDU_SEQUENCE_ERROR: 序列号错误
 * 
 * @note S格式APDU不包含ASDU数据，只验证序列号
 * @warning 序列号错误可能导致通信中断，需要重新同步
 * 
 * @see validate_i_format_apdu
 * @see validate_u_format_apdu
 * @see is_s_format_apdu
 */
protocol_error_t validate_s_format_apdu(protocol_validator_t* validator, const apdu_t* apdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证S格式APDU: 验证器=%p, APDU=%p", validator, apdu);
    
    if (validator == NULL || apdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器或APDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 提取接收序列号 */
    uint16_t receive_seq = ((uint16_t)apdu->control_field.control1 >> 1) | 
                           ((uint16_t)apdu->control_field.control2 << 7);
    
    LOG_DEBUG(LOG_MODULE_NAME, "S格式APDU接收序列号: 实际=%d, 期望=%d",
              receive_seq, validator->expected_receive_seq);
    
    /* 验证接收序列号 */
    if (receive_seq != validator->expected_receive_seq) {
        LOG_ERROR(LOG_MODULE_NAME, "S格式APDU接收序列号错误: 期望=%d, 实际=%d",
                  validator->expected_receive_seq, receive_seq);
        return PROTOCOL_ERROR_APDU_SEQUENCE_ERROR;
    }
    
    /* 验证序列号范围 */
    if (receive_seq > validator->max_receive_seq) {
        LOG_ERROR(LOG_MODULE_NAME, "S格式APDU接收序列号超出范围: 实际=%d, 最大=%d",
                  receive_seq, validator->max_receive_seq);
        return PROTOCOL_ERROR_APDU_SEQUENCE_ERROR;
    }
    
    /* 更新期望接收序列号 */
    validator->expected_receive_seq = (validator->expected_receive_seq + 1) % SEQUENCE_NUMBER_MODULO;
    
    LOG_DEBUG(LOG_MODULE_NAME, "S格式APDU接收序列号更新: 期望接收=%d",
              validator->expected_receive_seq);
    
    LOG_INFO(LOG_MODULE_NAME, "S格式APDU验证成功");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证U格式APDU
 * @details 验证U格式APDU的格式正确性。U格式APDU用于控制功能，
 *          不包含序列号，只需要验证基本格式。支持STARTDT、STOPDT、
 *          TESTFR等控制类型。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @param apdu U格式APDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 * 
 * @note U格式APDU不包含序列号，只验证基本格式
 * @warning U格式类型必须是有效的控制类型
 * 
 * @see validate_i_format_apdu
 * @see validate_s_format_apdu
 * @see is_u_format_apdu
 */
protocol_error_t validate_u_format_apdu(protocol_validator_t* validator, const apdu_t* apdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证U格式APDU: 验证器=%p, APDU=%p", validator, apdu);
    
    if (validator == NULL || apdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器或APDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* U格式APDU不需要序列号验证，只需要验证格式 */
    LOG_INFO(LOG_MODULE_NAME, "U格式APDU验证成功");
    return PROTOCOL_SUCCESS;
}

/* ==================== ASDU验证函数实现 ==================== */

/**
 * @brief 验证ASDU消息
 * @details 验证ASDU消息的完整性和正确性。函数会验证ASDU的基本结构、
 *          类型标识、数据内容等，然后根据ASDU类型进行特定的验证。
 *          支持多种ASDU类型的验证，包括遥信、遥测、控制命令等。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @param asdu ASDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_ASDU_INVALID_TYPE: 无效类型标识
 *         - PROTOCOL_ERROR_ASDU_DATA_MISMATCH: 数据不匹配
 * 
 * @note 验证器会根据ASDU类型进行相应的验证
 * @warning 验证失败表示ASDU格式错误，不应继续处理
 * 
 * @see validate_asdu_type
 * @see validate_asdu_data
 * @see validate_single_point_asdu
 * @see validate_double_point_asdu
 */
protocol_error_t validate_asdu_message(protocol_validator_t* validator, const asdu_t* asdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证ASDU消息: 验证器=%p, ASDU=%p, 类型ID=%d", validator, asdu, asdu ? asdu->type_id : -1);
    
    if (validator == NULL || asdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器或ASDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 验证ASDU基本结构 */
    protocol_error_t result = validate_asdu_type(asdu);
    if (result != PROTOCOL_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU类型验证失败: %d", result);
        return result;
    }
    
    result = validate_asdu_data(asdu);
    if (result != PROTOCOL_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU数据验证失败: %d", result);
        return result;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "ASDU基本结构验证通过，开始类型特定验证: 类型ID=%d", asdu->type_id);
    
    /* 根据类型进行特定验证 */
    switch (asdu->type_id) {
        case TYPE_ID_SINGLE_POINT:
        case TYPE_ID_SINGLE_POINT_SOE:
            LOG_DEBUG(LOG_MODULE_NAME, "验证单点信息ASDU");
            return validate_single_point_asdu(asdu);
            
        case TYPE_ID_DOUBLE_POINT:
        case TYPE_ID_DOUBLE_POINT_SOE:
            LOG_DEBUG(LOG_MODULE_NAME, "验证双点信息ASDU");
            return validate_double_point_asdu(asdu);
            
        case TYPE_ID_MEASUREMENT_NORMALIZED:
        case TYPE_ID_MEASUREMENT_SCALED:
        case TYPE_ID_MEASUREMENT_SHORT_FLOAT:
            LOG_DEBUG(LOG_MODULE_NAME, "验证测量值ASDU");
            return validate_measurement_asdu(asdu);
            
        case TYPE_ID_SINGLE_COMMAND:
            LOG_DEBUG(LOG_MODULE_NAME, "验证单命令ASDU");
            return validate_single_command_asdu(asdu);
            
        case TYPE_ID_DOUBLE_COMMAND:
            LOG_DEBUG(LOG_MODULE_NAME, "验证双命令ASDU");
            return validate_double_command_asdu(asdu);
            
        case TYPE_ID_TOTAL_INTERROGATION:
            LOG_DEBUG(LOG_MODULE_NAME, "验证总召唤ASDU");
            return validate_total_interrogation_asdu(asdu);
            
        case TYPE_ID_CLOCK_SYNC:
            LOG_DEBUG(LOG_MODULE_NAME, "验证时钟同步ASDU");
            return validate_clock_sync_asdu(asdu);
            
        default:
            LOG_DEBUG(LOG_MODULE_NAME, "未知ASDU类型，跳过特定验证: 类型ID=%d", asdu->type_id);
            return PROTOCOL_SUCCESS; /* 其他类型暂不验证 */
    }
}

protocol_error_t validate_single_point_asdu(const asdu_t* asdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证单点信息ASDU: ASDU=%p", asdu);
    
    if (asdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 验证信息对象数据 */
    if (asdu->info_object_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "单点信息ASDU数据指针为NULL");
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    size_t expected_size = asdu->vsq.number_of_objects * sizeof(single_point_info_t);
    size_t actual_size = asdu->length - ASDU_HEADER_SIZE;
    
    LOG_DEBUG(LOG_MODULE_NAME, "单点信息ASDU数据大小验证: 期望=%zu, 实际=%zu, 对象数=%d",
              expected_size, actual_size, asdu->vsq.number_of_objects);
    
    if (actual_size < expected_size) {
        LOG_ERROR(LOG_MODULE_NAME, "单点信息ASDU数据大小不匹配: 期望=%zu, 实际=%zu",
                  expected_size, actual_size);
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    /* 验证每个信息对象 */
    const single_point_info_t* info_objects = (const single_point_info_t*)asdu->info_object_data;
    for (uint8_t i = 0; i < asdu->vsq.number_of_objects; i++) {
        /* 验证信息对象地址 */
        if (!is_info_address_valid(info_objects[i].info_addr)) {
            LOG_ERROR(LOG_MODULE_NAME, "单点信息ASDU对象%d地址无效: %d", i, info_objects[i].info_addr);
            return PROTOCOL_ERROR_ASDU_INVALID_ADDRESS;
        }
        
        /* 验证SIQ品质描述词 */
        if (!is_siq_valid(info_objects[i].siq)) {
            LOG_ERROR(LOG_MODULE_NAME, "单点信息ASDU对象%d SIQ无效: 0x%02X", i, info_objects[i].siq);
            return PROTOCOL_ERROR_DATA_INVALID_QUALITY;
        }
    }
    
    LOG_INFO(LOG_MODULE_NAME, "单点信息ASDU验证成功: 对象数=%d", asdu->vsq.number_of_objects);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证双点信息ASDU
 * @details 验证双点信息ASDU的完整性和有效性。函数会检查ASDU头部、
 *          信息对象数据大小、信息对象地址和DIQ品质描述词等。
 *          支持M_DP_NA_1、M_DP_TA_1等类型标识。
 * 
 * @param asdu ASDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_ASDU_DATA_MISMATCH: 数据不匹配
 *         - PROTOCOL_ERROR_ASDU_INVALID_ADDRESS: 无效地址
 *         - PROTOCOL_ERROR_DATA_INVALID_QUALITY: 无效品质
 * 
 * @note 验证包括数据大小、地址范围和品质描述词
 * @warning 信息对象数据必须完整且有效
 * 
 * @see double_point_info_t
 * @see is_info_address_valid
 * @see is_diq_valid
 * @see M_DP_NA_1
 * @see M_DP_TA_1
 */
protocol_error_t validate_double_point_asdu(const asdu_t* asdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证双点信息ASDU: ASDU=%p", asdu);
    
    if (asdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 验证信息对象数据 */
    if (asdu->info_object_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "双点信息ASDU数据指针为NULL");
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    size_t expected_size = asdu->vsq.number_of_objects * sizeof(double_point_info_t);
    size_t actual_size = asdu->length - ASDU_HEADER_SIZE;
    
    LOG_DEBUG(LOG_MODULE_NAME, "双点信息ASDU数据大小验证: 期望=%zu, 实际=%zu, 对象数=%d",
              expected_size, actual_size, asdu->vsq.number_of_objects);
    
    if (actual_size < expected_size) {
        LOG_ERROR(LOG_MODULE_NAME, "双点信息ASDU数据大小不匹配: 期望=%zu, 实际=%zu",
                  expected_size, actual_size);
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    /* 验证每个信息对象 */
    const double_point_info_t* info_objects = (const double_point_info_t*)asdu->info_object_data;
    for (uint8_t i = 0; i < asdu->vsq.number_of_objects; i++) {
        /* 验证信息对象地址 */
        if (!is_info_address_valid(info_objects[i].info_addr)) {
            LOG_ERROR(LOG_MODULE_NAME, "双点信息ASDU对象%d地址无效: %d", i, info_objects[i].info_addr);
            return PROTOCOL_ERROR_ASDU_INVALID_ADDRESS;
        }
        
        /* 验证DIQ品质描述词 */
        if (!is_diq_valid(info_objects[i].diq)) {
            LOG_ERROR(LOG_MODULE_NAME, "双点信息ASDU对象%d DIQ无效: 0x%02X", i, info_objects[i].diq);
            return PROTOCOL_ERROR_DATA_INVALID_QUALITY;
        }
    }
    
    LOG_INFO(LOG_MODULE_NAME, "双点信息ASDU验证成功: 对象数=%d", asdu->vsq.number_of_objects);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证测量值ASDU
 * @details 验证测量值ASDU的完整性和有效性。函数会检查ASDU头部、
 *          信息对象数据大小、信息对象地址和QDS品质描述词等。
 *          支持M_ME_NA_1、M_ME_NB_1、M_ME_NC_1等类型标识。
 * 
 * @param asdu ASDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_ASDU_DATA_MISMATCH: 数据不匹配
 *         - PROTOCOL_ERROR_ASDU_INVALID_ADDRESS: 无效地址
 *         - PROTOCOL_ERROR_DATA_INVALID_QUALITY: 无效品质
 * 
 * @note 验证包括数据大小、地址范围和品质描述词
 * @warning 信息对象数据必须完整且有效
 * 
 * @see measurement_info_t
 * @see is_info_address_valid
 * @see is_qds_valid
 * @see M_ME_NA_1
 * @see M_ME_NB_1
 * @see M_ME_NC_1
 */
protocol_error_t validate_measurement_asdu(const asdu_t* asdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证测量值ASDU: ASDU=%p, 类型ID=%d", asdu, asdu ? asdu->type_id : -1);
    
    if (asdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 验证信息对象数据 */
    if (asdu->info_object_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "测量值ASDU数据指针为NULL");
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    size_t expected_size = asdu->vsq.number_of_objects * sizeof(measurement_info_t);
    size_t actual_size = asdu->length - ASDU_HEADER_SIZE;
    
    LOG_DEBUG(LOG_MODULE_NAME, "测量值ASDU数据大小验证: 期望=%zu, 实际=%zu, 对象数=%d",
              expected_size, actual_size, asdu->vsq.number_of_objects);
    
    if (actual_size < expected_size) {
        LOG_ERROR(LOG_MODULE_NAME, "测量值ASDU数据大小不匹配: 期望=%zu, 实际=%zu",
                  expected_size, actual_size);
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    /* 验证每个信息对象 */
    const measurement_info_t* info_objects = (const measurement_info_t*)asdu->info_object_data;
    for (uint8_t i = 0; i < asdu->vsq.number_of_objects; i++) {
        /* 验证信息对象地址 */
        if (!is_info_address_valid(info_objects[i].info_addr)) {
            LOG_ERROR(LOG_MODULE_NAME, "测量值ASDU对象%d地址无效: %d", i, info_objects[i].info_addr);
            return PROTOCOL_ERROR_ASDU_INVALID_ADDRESS;
        }
        
        /* 验证QDS品质描述词 */
        if (!is_qds_valid(info_objects[i].qds)) {
            LOG_ERROR(LOG_MODULE_NAME, "测量值ASDU对象%d QDS无效: 0x%02X", i, info_objects[i].qds);
            return PROTOCOL_ERROR_DATA_INVALID_QUALITY;
        }
        
        /* 验证测量值 */
        switch (asdu->type_id) {
            case TYPE_ID_MEASUREMENT_NORMALIZED:
                if (!is_normalized_value_valid((s16)info_objects[i].value)) {
                    LOG_ERROR(LOG_MODULE_NAME, "测量值ASDU对象%d 标度化值无效: %d", i, (s16)info_objects[i].value);
                    return PROTOCOL_ERROR_DATA_INVALID_VALUE;
                }
                break;
                
            case TYPE_ID_MEASUREMENT_SCALED:
                if (!is_scaled_value_valid((s16)info_objects[i].value)) {
                    LOG_ERROR(LOG_MODULE_NAME, "测量值ASDU对象%d 标度化值无效: %d", i, (s16)info_objects[i].value);
                    return PROTOCOL_ERROR_DATA_INVALID_VALUE;
                }
                break;
                
            case TYPE_ID_MEASUREMENT_SHORT_FLOAT:
                {
                    float float_value;
                    memcpy(&float_value, &info_objects[i].value, sizeof(float));
                    if (!is_short_float_valid(float_value)) {
                        LOG_ERROR(LOG_MODULE_NAME, "测量值ASDU对象%d 短浮点值无效: %f", i, float_value);
                        return PROTOCOL_ERROR_DATA_INVALID_VALUE;
                    }
                }
                break;
        }
    }
    
    LOG_INFO(LOG_MODULE_NAME, "测量值ASDU验证成功: 类型ID=%d, 对象数=%d", asdu->type_id, asdu->vsq.number_of_objects);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证单命令ASDU
 * @details 验证单命令ASDU的完整性和有效性。函数会检查ASDU头部、
 *          信息对象数据大小、信息对象地址和SCO命令限定词等。
 *          支持C_SC_NA_1类型标识。
 * 
 * @param asdu ASDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_ASDU_DATA_MISMATCH: 数据不匹配
 *         - PROTOCOL_ERROR_ASDU_INVALID_ADDRESS: 无效地址
 *         - PROTOCOL_ERROR_DATA_INVALID_QUALITY: 无效品质
 * 
 * @note 验证包括数据大小、地址范围和命令限定词
 * @warning 信息对象数据必须完整且有效
 * 
 * @see single_command_info_t
 * @see is_info_address_valid
 * @see is_sco_valid
 * @see C_SC_NA_1
 */
protocol_error_t validate_single_command_asdu(const asdu_t* asdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证单命令ASDU: ASDU=%p", asdu);
    
    if (asdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 验证信息对象数据 */
    if (asdu->info_object_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "单命令ASDU数据指针为NULL");
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    size_t expected_size = asdu->vsq.number_of_objects * sizeof(single_command_info_t);
    size_t actual_size = asdu->length - ASDU_HEADER_SIZE;
    
    LOG_DEBUG(LOG_MODULE_NAME, "单命令ASDU数据大小验证: 期望=%zu, 实际=%zu, 对象数=%d",
              expected_size, actual_size, asdu->vsq.number_of_objects);
    
    if (actual_size < expected_size) {
        LOG_ERROR(LOG_MODULE_NAME, "单命令ASDU数据大小不匹配: 期望=%zu, 实际=%zu",
                  expected_size, actual_size);
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    /* 验证每个信息对象 */
    const single_command_info_t* info_objects = (const single_command_info_t*)asdu->info_object_data;
    for (uint8_t i = 0; i < asdu->vsq.number_of_objects; i++) {
        /* 验证信息对象地址 */
        if (!is_info_address_valid(info_objects[i].info_addr)) {
            LOG_ERROR(LOG_MODULE_NAME, "单命令ASDU对象%d地址无效: %d", i, info_objects[i].info_addr);
            return PROTOCOL_ERROR_ASDU_INVALID_ADDRESS;
        }
        
        /* 验证QOC命令限定词 */
        if (!is_qos_valid(info_objects[i].qos)) {
            LOG_ERROR(LOG_MODULE_NAME, "单命令ASDU对象%d QOS无效: 0x%02X", i, info_objects[i].qos);
            return PROTOCOL_ERROR_DATA_INVALID_QUALITY;
        }
    }
    
    LOG_INFO(LOG_MODULE_NAME, "单命令ASDU验证成功: 对象数=%d", asdu->vsq.number_of_objects);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证双命令ASDU
 * @details 验证双命令ASDU的完整性和有效性。函数会检查ASDU头部、
 *          信息对象数据大小、信息对象地址和QOC命令限定词等。
 *          支持C_DC_NA_1类型标识。
 * 
 * @param asdu ASDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_ASDU_DATA_MISMATCH: 数据不匹配
 *         - PROTOCOL_ERROR_ASDU_INVALID_ADDRESS: 无效地址
 *         - PROTOCOL_ERROR_DATA_INVALID_QUALITY: 无效品质
 * 
 * @note 验证包括数据大小、地址范围和命令限定词
 * @warning 信息对象数据必须完整且有效
 * 
 * @see double_command_info_t
 * @see is_info_address_valid
 * @see is_qos_valid
 * @see C_DC_NA_1
 */
protocol_error_t validate_double_command_asdu(const asdu_t* asdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证双命令ASDU: ASDU=%p", asdu);
    
    if (asdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 验证信息对象数据 */
    if (asdu->info_object_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "双命令ASDU数据指针为NULL");
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    size_t expected_size = asdu->vsq.number_of_objects * sizeof(double_command_info_t);
    size_t actual_size = asdu->length - ASDU_HEADER_SIZE;
    
    LOG_DEBUG(LOG_MODULE_NAME, "双命令ASDU数据大小验证: 期望=%zu, 实际=%zu, 对象数=%d",
              expected_size, actual_size, asdu->vsq.number_of_objects);
    
    if (actual_size < expected_size) {
        LOG_ERROR(LOG_MODULE_NAME, "双命令ASDU数据大小不匹配: 期望=%zu, 实际=%zu",
                  expected_size, actual_size);
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    /* 验证每个信息对象 */
    const double_command_info_t* info_objects = (const double_command_info_t*)asdu->info_object_data;
    for (uint8_t i = 0; i < asdu->vsq.number_of_objects; i++) {
        /* 验证信息对象地址 */
        if (!is_info_address_valid(info_objects[i].info_addr)) {
            LOG_ERROR(LOG_MODULE_NAME, "双命令ASDU对象%d地址无效: %d", i, info_objects[i].info_addr);
            return PROTOCOL_ERROR_ASDU_INVALID_ADDRESS;
        }
        
        /* 验证QOC命令限定词 */
        if (!is_qos_valid(info_objects[i].qos)) {
            LOG_ERROR(LOG_MODULE_NAME, "双命令ASDU对象%d QOS无效: 0x%02X", i, info_objects[i].qos);
            return PROTOCOL_ERROR_DATA_INVALID_QUALITY;
        }
    }
    
    LOG_INFO(LOG_MODULE_NAME, "双命令ASDU验证成功: 对象数=%d", asdu->vsq.number_of_objects);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证总召唤ASDU
 * @details 验证总召唤ASDU的完整性和有效性。函数会检查ASDU头部、
 *          信息对象数据大小和QOI限定词等。支持C_IC_NA_1类型标识。
 * 
 * @param asdu ASDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_ASDU_DATA_MISMATCH: 数据不匹配
 *         - PROTOCOL_ERROR_DATA_INVALID_QUALITY: 无效品质
 * 
 * @note 验证包括数据大小和QOI限定词
 * @warning QOI必须是有效的限定词值
 * 
 * @see qoi_t
 * @see is_qoi_valid
 * @see C_IC_NA_1
 */
protocol_error_t validate_total_interrogation_asdu(const asdu_t* asdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证总召唤ASDU: ASDU=%p", asdu);
    
    if (asdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 验证信息对象数据 */
    if (asdu->info_object_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "总召唤ASDU数据指针为NULL");
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    size_t expected_size = sizeof(qoi_t);
    size_t actual_size = asdu->length - ASDU_HEADER_SIZE;
    
    LOG_DEBUG(LOG_MODULE_NAME, "总召唤ASDU数据大小验证: 期望=%zu, 实际=%zu",
              expected_size, actual_size);
    
    if (actual_size < expected_size) {
        LOG_ERROR(LOG_MODULE_NAME, "总召唤ASDU数据大小不匹配: 期望=%zu, 实际=%zu",
                  expected_size, actual_size);
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    /* 验证QOI召唤限定词 */
    const qoi_t* qoi = (const qoi_t*)asdu->info_object_data;
    if (!is_qoi_valid(*(uint8_t*)qoi)) {
        LOG_ERROR(LOG_MODULE_NAME, "总召唤ASDU QOI无效: %d", *qoi);
        return PROTOCOL_ERROR_DATA_INVALID_QUALITY;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "总召唤ASDU验证成功: QOI=%d", *qoi);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证时钟同步ASDU
 * @details 验证时钟同步ASDU的完整性和有效性。函数会检查ASDU头部、
 *          信息对象数据大小和时间戳格式等。支持C_CS_NA_1类型标识。
 * 
 * @param asdu ASDU结构指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 验证成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_ASDU_DATA_MISMATCH: 数据不匹配
 *         - PROTOCOL_ERROR_INVALID_TIMESTAMP: 无效时间戳
 * 
 * @note 验证包括数据大小和时间戳格式
 * @warning 时间戳必须是有效的CP56Time2a格式
 * 
 * @see cp56time2a_t
 * @see validate_cp56time2a
 * @see C_CS_NA_1
 */
protocol_error_t validate_clock_sync_asdu(const asdu_t* asdu) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证时钟同步ASDU: ASDU=%p", asdu);
    
    if (asdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "ASDU指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    /* 验证信息对象数据 */
    if (asdu->info_object_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "时钟同步ASDU数据指针为NULL");
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    size_t expected_size = sizeof(cp56time2a_t);
    size_t actual_size = asdu->length - ASDU_HEADER_SIZE;
    
    LOG_DEBUG(LOG_MODULE_NAME, "时钟同步ASDU数据大小验证: 期望=%zu, 实际=%zu",
              expected_size, actual_size);
    
    if (actual_size < expected_size) {
        LOG_ERROR(LOG_MODULE_NAME, "时钟同步ASDU数据大小不匹配: 期望=%zu, 实际=%zu",
                  expected_size, actual_size);
        return PROTOCOL_ERROR_ASDU_DATA_MISMATCH;
    }
    
    /* 验证时间戳 */
    const cp56time2a_t* timestamp = (const cp56time2a_t*)asdu->info_object_data;
    protocol_error_t result = validate_cp56time2a(timestamp);
    
    if (result == PROTOCOL_SUCCESS) {
        LOG_INFO(LOG_MODULE_NAME, "时钟同步ASDU验证成功");
    } else {
        LOG_ERROR(LOG_MODULE_NAME, "时钟同步ASDU时间戳验证失败: %d", result);
    }
    
    return result;
}

/* ==================== 验证器状态管理函数实现 ==================== */

/**
 * @brief 重置协议验证器
 * @details 重置协议验证器的内部状态，将期望的发送和接收序列号重置为0。
 *          用于重新开始协议会话或清除验证器状态。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 重置成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 * 
 * @note 重置后验证器将重新开始序列号验证
 * @warning 重置会清除所有验证器状态信息
 * 
 * @see protocol_validator_t
 * @see set_expected_sequences
 */
protocol_error_t reset_protocol_validator(protocol_validator_t* validator) {
    LOG_DEBUG(LOG_MODULE_NAME, "重置协议验证器: 验证器=%p", validator);
    
    if (validator == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "重置前序列号: 期望发送=%d, 期望接收=%d",
              validator->expected_send_seq, validator->expected_receive_seq);
    
    validator->expected_send_seq = 0;
    validator->expected_receive_seq = 0;
    
    LOG_INFO(LOG_MODULE_NAME, "协议验证器重置成功: 验证器=%p", validator);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 设置期望序列号
 * @details 设置协议验证器期望的发送和接收序列号。
 *          用于同步协议会话的序列号状态。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @param send_seq 期望的发送序列号，范围0-32767
 * @param receive_seq 期望的接收序列号，范围0-32767
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 设置成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_INVALID_PARAM: 无效参数
 * 
 * @note 序列号必须在有效范围内
 * @warning 设置错误的序列号可能导致验证失败
 * 
 * @see protocol_validator_t
 * @see reset_protocol_validator
 */
protocol_error_t set_expected_sequences(protocol_validator_t* validator, uint16_t send_seq, uint16_t receive_seq) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置期望序列号: 验证器=%p, 发送=%d, 接收=%d", validator, send_seq, receive_seq);
    
    if (validator == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    if (send_seq > validator->max_send_seq || receive_seq > validator->max_receive_seq) {
        LOG_ERROR(LOG_MODULE_NAME, "序列号超出范围: 发送=%d(最大=%d), 接收=%d(最大=%d)",
                  send_seq, validator->max_send_seq, receive_seq, validator->max_receive_seq);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "设置前序列号: 期望发送=%d, 期望接收=%d",
              validator->expected_send_seq, validator->expected_receive_seq);
    
    validator->expected_send_seq = send_seq;
    validator->expected_receive_seq = receive_seq;
    
    LOG_INFO(LOG_MODULE_NAME, "期望序列号设置成功: 发送=%d, 接收=%d", send_seq, receive_seq);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 获取期望序列号
 * @details 获取协议验证器当前期望的发送和接收序列号。
 *          用于查询验证器的序列号状态。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @param send_seq 发送序列号输出，不能为NULL
 * @param receive_seq 接收序列号输出，不能为NULL
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 获取成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 * 
 * @note 获取的序列号是验证器当前期望的值
 * @warning 输出参数不能为NULL
 * 
 * @see protocol_validator_t
 * @see set_expected_sequences
 */
protocol_error_t get_expected_sequences(const protocol_validator_t* validator, uint16_t* send_seq, uint16_t* receive_seq) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取期望序列号: 验证器=%p", validator);
    
    if (validator == NULL || send_seq == NULL || receive_seq == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器或输出参数指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    *send_seq = validator->expected_send_seq;
    *receive_seq = validator->expected_receive_seq;
    
    LOG_DEBUG(LOG_MODULE_NAME, "获取序列号成功: 发送=%d, 接收=%d", *send_seq, *receive_seq);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 设置最大序列号
 * @details 设置协议验证器的最大发送和接收序列号限制。
 *          用于配置验证器的序列号范围。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @param max_send_seq 最大发送序列号，范围0-32767
 * @param max_receive_seq 最大接收序列号，范围0-32767
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 设置成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_INVALID_PARAM: 无效参数
 * 
 * @note 序列号必须在有效范围内
 * @warning 设置错误的序列号可能导致验证失败
 * 
 * @see protocol_validator_t
 * @see MAX_SEND_SEQUENCE_NUMBER
 * @see MAX_RECEIVE_SEQUENCE_NUMBER
 */
protocol_error_t set_max_sequences(protocol_validator_t* validator, uint16_t max_send_seq, uint16_t max_receive_seq) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置最大序列号: 验证器=%p, 最大发送=%d, 最大接收=%d", validator, max_send_seq, max_receive_seq);
    
    if (validator == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    if (max_send_seq > MAX_SEND_SEQUENCE_NUMBER || max_receive_seq > MAX_RECEIVE_SEQUENCE_NUMBER) {
        LOG_ERROR(LOG_MODULE_NAME, "最大序列号超出范围: 发送=%d(最大=%d), 接收=%d(最大=%d)",
                  max_send_seq, MAX_SEND_SEQUENCE_NUMBER, max_receive_seq, MAX_RECEIVE_SEQUENCE_NUMBER);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "设置前最大序列号: 最大发送=%d, 最大接收=%d",
              validator->max_send_seq, validator->max_receive_seq);
    
    validator->max_send_seq = max_send_seq;
    validator->max_receive_seq = max_receive_seq;
    
    LOG_INFO(LOG_MODULE_NAME, "最大序列号设置成功: 最大发送=%d, 最大接收=%d", max_send_seq, max_receive_seq);
    return PROTOCOL_SUCCESS;
}

/* ==================== 验证器状态查询函数实现 ==================== */

/**
 * @brief 检查协议验证器是否已初始化
 * @details 检查协议验证器是否已经正确初始化。
 *          用于验证验证器状态。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @return 初始化状态
 *         - 1: 已初始化
 *         - 0: 未初始化或验证器为NULL
 * 
 * @note 此函数是线程安全的
 * @warning 验证器为NULL时返回0
 * 
 * @see protocol_validator_t
 * @see init_protocol_validator
 */
int is_protocol_validator_initialized(const protocol_validator_t* validator) {
    LOG_DEBUG(LOG_MODULE_NAME, "检查验证器初始化状态: 验证器=%p", validator);
    
    if (validator == NULL) {
        LOG_DEBUG(LOG_MODULE_NAME, "验证器指针为NULL，返回未初始化");
        return 0;
    }
    
    int initialized = validator->initialized;
    LOG_DEBUG(LOG_MODULE_NAME, "验证器初始化状态: %s", initialized ? "已初始化" : "未初始化");
    LOG_INFO(LOG_MODULE_NAME, "验证器初始化状态检查完成: %s", initialized ? "已初始化" : "未初始化");
    
    return initialized;
}

/**
 * @brief 获取协议验证器状态
 * @details 获取协议验证器的详细状态信息，包括初始化状态和序列号信息。
 *          用于调试和状态监控。
 * 
 * @param validator 协议验证器指针，不能为NULL
 * @param status 状态字符串输出缓冲区，不能为NULL
 * @param status_size 缓冲区大小
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 获取成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 空指针错误
 *         - PROTOCOL_ERROR_BUFFER_TOO_SMALL: 缓冲区太小
 * 
 * @note 状态字符串会自动截断以适配缓冲区大小
 * @warning 缓冲区必须足够大以容纳状态字符串
 * 
 * @see protocol_validator_t
 * @see is_protocol_validator_initialized
 */
protocol_error_t get_protocol_validator_status(const protocol_validator_t* validator, char* status, size_t status_size) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取验证器状态: 验证器=%p, 状态缓冲区=%p, 大小=%zu", validator, status, status_size);
    
    if (validator == NULL || status == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "验证器或状态缓冲区指针为NULL");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    if (status_size == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "状态缓冲区大小为0");
        return PROTOCOL_ERROR_BUFFER_TOO_SMALL;
    }
    
    if (!validator->initialized) {
        LOG_DEBUG(LOG_MODULE_NAME, "验证器未初始化，返回未初始化状态");
        strncpy(status, "未初始化", status_size - 1);
    } else {
        LOG_DEBUG(LOG_MODULE_NAME, "验证器已初始化，返回详细状态信息");
        snprintf(status, status_size, "已初始化 - 发送序列号: %u, 接收序列号: %u", 
                validator->expected_send_seq, validator->expected_receive_seq);
    }
    
    status[status_size - 1] = '\0';
    
    LOG_INFO(LOG_MODULE_NAME, "验证器状态获取成功: %s", status);
    return PROTOCOL_SUCCESS;
}

